< Summary

Class:GDX.Tables.StableTable
Assembly:GDX
File(s):D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs
Covered lines:0
Uncovered lines:1174
Coverable lines:1174
Total lines:1786
Line coverage:0% (0 of 1174)
Covered branches:0
Total branches:0
Covered methods:0
Total methods:164
Method coverage:0% (0 of 164)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
StableTable()0%2100%
GetDataVersion()0%2100%
GetColumnCount()0%2100%
GetRowCount()0%2100%
GetDisplayName()0%2100%
SetDisplayName(...)0%2100%
GetFlag(...)0%2100%
SetFlag(...)0%2100%
GetAllRowDescriptions()0%20400%
GetRowDescription(...)0%12300%
GetRowDescription(...)0%2100%
SetAllRowDescriptionsOrder(...)0%2100%
GetColumnDescription(...)0%30500%
GetColumnDescription(...)0%2100%
SetAllColumnDescriptionsOrder(...)0%2100%
GetAllColumnDescriptions()0%12300%
AssertColumnIDValid(...)0%20400%
AssertRowIDValid(...)0%30500%
SetColumnName(...)0%2100%
GetColumnName(...)0%2100%
SetRowName(...)0%2100%
GetRowName(...)0%2100%
GetRowNameRef(...)0%2100%
GetColumnNameRef(...)0%2100%
AddRow(...)0%2401500%
AddRows(...)0%4202000%
AddRows(...)0%4202000%
RemoveRow(...)0%6200%
AddColumn(...)0%9923100%
RemoveColumn(...)0%9303000%
SetString(...)0%2100%
SetBool(...)0%2100%
SetChar(...)0%2100%
SetSByte(...)0%2100%
SetByte(...)0%2100%
SetShort(...)0%2100%
SetUShort(...)0%2100%
SetInt(...)0%2100%
SetUInt(...)0%2100%
SetLong(...)0%2100%
SetULong(...)0%2100%
SetFloat(...)0%2100%
SetDouble(...)0%2100%
SetVector2(...)0%2100%
SetVector3(...)0%2100%
SetVector4(...)0%2100%
SetVector2Int(...)0%2100%
SetVector3Int(...)0%2100%
SetQuaternion(...)0%2100%
SetRect(...)0%2100%
SetRectInt(...)0%2100%
SetColor(...)0%2100%
SetLayerMask(...)0%2100%
SetBounds(...)0%2100%
SetBoundsInt(...)0%2100%
SetHash128(...)0%2100%
SetGradient(...)0%2100%
SetAnimationCurve(...)0%2100%
SetObject(...)0%2100%
GetString(...)0%2100%
GetBool(...)0%2100%
GetChar(...)0%2100%
GetSByte(...)0%2100%
GetByte(...)0%2100%
GetShort(...)0%2100%
GetUShort(...)0%2100%
GetInt(...)0%2100%
GetUInt(...)0%2100%
GetLong(...)0%2100%
GetULong(...)0%2100%
GetFloat(...)0%2100%
GetDouble(...)0%2100%
GetVector2(...)0%2100%
GetVector3(...)0%2100%
GetVector4(...)0%2100%
GetVector2Int(...)0%2100%
GetVector3Int(...)0%2100%
GetQuaternion(...)0%2100%
GetRect(...)0%2100%
GetRectInt(...)0%2100%
GetColor(...)0%2100%
GetLayerMask(...)0%2100%
GetBounds(...)0%2100%
GetBoundsInt(...)0%2100%
GetHash128(...)0%2100%
GetGradient(...)0%2100%
GetAnimationCurve(...)0%2100%
GetObject(...)0%2100%
GetStringRef(...)0%2100%
GetBoolRef(...)0%2100%
GetCharRef(...)0%2100%
GetSbyteRef(...)0%2100%
GetByteRef(...)0%2100%
GetShortRef(...)0%2100%
GetUshortRef(...)0%2100%
GetIntRef(...)0%2100%
GetUintRef(...)0%2100%
GetLongRef(...)0%2100%
GetUlongRef(...)0%2100%
GetFloatRef(...)0%2100%
GetDoubleRef(...)0%2100%
GetVector2Ref(...)0%2100%
GetVector3Ref(...)0%2100%
GetVector4Ref(...)0%2100%
GetVector2IntRef(...)0%2100%
GetVector3IntRef(...)0%2100%
GetQuaternionRef(...)0%2100%
GetRectRef(...)0%2100%
GetRectIntRef(...)0%2100%
GetColorRef(...)0%2100%
GetLayerMaskRef(...)0%2100%
GetBoundsRef(...)0%2100%
GetBoundsIntRef(...)0%2100%
GetHash128Ref(...)0%2100%
GetGradientRef(...)0%2100%
GetAnimationCurveRef(...)0%2100%
GetObjectRef(...)0%2100%
GetStringColumn(...)0%2100%
GetBoolColumn(...)0%2100%
GetCharColumn(...)0%2100%
GetSbyteColumn(...)0%2100%
GetByteColumn(...)0%2100%
GetShortColumn(...)0%2100%
GetUshortColumn(...)0%2100%
GetIntColumn(...)0%2100%
GetUintColumn(...)0%2100%
GetLongColumn(...)0%2100%
GetUlongColumn(...)0%2100%
GetFloatColumn(...)0%2100%
GetDoubleColumn(...)0%2100%
GetVector2Column(...)0%2100%
GetVector3Column(...)0%2100%
GetVector4Column(...)0%2100%
GetVector2IntColumn(...)0%2100%
GetVector3IntColumn(...)0%2100%
GetQuaternionColumn(...)0%2100%
GetRectColumn(...)0%2100%
GetRectIntColumn(...)0%2100%
GetColorColumn(...)0%2100%
GetLayerMaskColumn(...)0%2100%
GetBoundsColumn(...)0%2100%
GetBoundsIntColumn(...)0%2100%
GetHash128Column(...)0%2100%
GetGradientColumn(...)0%2100%
GetAnimationCurveColumn(...)0%2100%
GetObjectColumn(...)0%2100%
SetColumnOrder(...)0%20400%
SetAllColumnOrders(...)0%6200%
SetRowOrder(...)0%20400%
SetAllRowOrders(...)0%6200%
ReSortRows[T](...)0%30500%
AddColumnInternal[T](...)0%4202000%
RemoveColumnInternal[T](...)0%6200%
InsertRowsOfTypeInternal[T](...)0%42600%
DeleteRowsOfTypeInternal[T](...)0%30500%
GetCellRef[T](...)0%2100%
GetCell[T](...)0%2100%
SetCell[T](...)0%2100%
GetColumn[T](...)0%2100%
SetRowOrderForColumns[T](...)0%56700%
AssertSortedColumnsArgValid(...)0%20400%
AssertColumnSortOrderValid(...)0%12300%
AssertRowSortOrderValid(...)0%12300%
AssertSorteRowsArgValid(...)0%20400%

File(s)

D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs

#LineLine coverage
 1// Copyright (c) 2020-2023 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using System;
 6using GDX.Collections;
 7using UnityEngine;
 8
 9namespace GDX.Tables
 10{
 11
 12    [CreateAssetMenu(menuName = "GDX/Stable Table", fileName = "GDXStableTable")]
 13    [Serializable]
 14    public class StableTable : ScriptableObject, ITable
 15    {
 16        [Serializable]
 17        internal struct ColumnEntry
 18        {
 19            public Serializable.SerializableTypes ColumnType;
 20            public int columnDenseIndex;
 21        }
 22
 023        [SerializeField] internal string m_DisplayName = "GDXStableTable";
 24
 25        [SerializeField] internal ArrayHolder<string>[] allStringColumns;
 26        [SerializeField] internal ArrayHolder<bool>[] allBoolColumns;
 27        [SerializeField] internal ArrayHolder<char>[] allCharColumns;
 28        [SerializeField] internal ArrayHolder<sbyte>[] allSbyteColumns;
 29        [SerializeField] internal ArrayHolder<byte>[] allByteColumns;
 30        [SerializeField] internal ArrayHolder<short>[] allShortColumns;
 31        [SerializeField] internal ArrayHolder<ushort>[] allUshortColumns;
 32        [SerializeField] internal ArrayHolder<int>[] allIntColumns;
 33        [SerializeField] internal ArrayHolder<uint>[] allUintColumns;
 34        [SerializeField] internal ArrayHolder<long>[] allLongColumns;
 35        [SerializeField] internal ArrayHolder<ulong>[] allUlongColumns;
 36        [SerializeField] internal ArrayHolder<float>[] allFloatColumns;
 37        [SerializeField] internal ArrayHolder<double>[] allDoubleColumns;
 38        [SerializeField] internal ArrayHolder<Vector2>[] allVector2Columns;
 39        [SerializeField] internal ArrayHolder<Vector3>[] allVector3Columns;
 40        [SerializeField] internal ArrayHolder<Vector4>[] allVector4Columns;
 41        [SerializeField] internal ArrayHolder<Vector2Int>[] allVector2IntColumns;
 42        [SerializeField] internal ArrayHolder<Vector3Int>[] allVector3IntColumns;
 43        [SerializeField] internal ArrayHolder<Quaternion>[] allQuaternionColumns;
 44        [SerializeField] internal ArrayHolder<Rect>[] allRectColumns;
 45        [SerializeField] internal ArrayHolder<RectInt>[] allRectIntColumns;
 46        [SerializeField] internal ArrayHolder<Color>[] allColorColumns;
 47        [SerializeField] internal ArrayHolder<LayerMask>[] allLayerMaskColumns;
 48        [SerializeField] internal ArrayHolder<Bounds>[] allBoundsColumns;
 49        [SerializeField] internal ArrayHolder<BoundsInt>[] allBoundsIntColumns;
 50        [SerializeField] internal ArrayHolder<Hash128>[] allHash128Columns;
 51        [SerializeField] internal ArrayHolder<Gradient>[] allGradientColumns;
 52        [SerializeField] internal ArrayHolder<AnimationCurve>[] allAnimationCurveColumns;
 53        [SerializeField] internal ArrayHolder<UnityEngine.Object>[] allObjectRefColumns;
 054        [SerializeField] internal ArrayHolder<string>[] allColumnNames = new ArrayHolder<string>[Serializable.Serializab
 55
 56        [SerializeField] internal int[] rowIDToDenseIndexMap;
 57        [SerializeField] internal int[] rowDenseIndexToIDMap;
 58        [SerializeField] internal string[] rowNames;
 59        [SerializeField] internal int rowEntriesFreeListHead;
 60
 61        [SerializeField]
 62        internal int rowCount;
 63
 64        [SerializeField] internal ColumnEntry[] columnIDToDenseIndexMap;
 65        [SerializeField] internal int[] columnIDToSortOrderMap;
 66        [SerializeField] internal int[] sortedOrderToColumnIDMap;
 67
 68        // TODO move with other block
 069        [SerializeField] ArrayHolder<int>[] columnDenseIndexToIDMap = new ArrayHolder<int>[Serializable.SerializableType
 70
 71        [SerializeField]
 72        internal int columnEntriesFreeListHead;
 73
 74        [SerializeField]
 75        internal int combinedColumnCount;
 76
 77        [SerializeField]
 078        internal ulong dataVersion = 1;
 79
 80        [SerializeField] BitArray8 m_Flags;
 81
 82        public ulong GetDataVersion()
 083        {
 084            return dataVersion;
 085        }
 86
 87        /// <inheritdoc />
 88        public int GetColumnCount()
 089        {
 090            return combinedColumnCount;
 091        }
 92
 93        /// <inheritdoc />
 94        public int GetRowCount()
 095        {
 096            return rowCount;
 097        }
 98
 99        public string GetDisplayName()
 0100        {
 0101            return m_DisplayName;
 0102        }
 103
 104        public void SetDisplayName(string displayName)
 0105        {
 0106            m_DisplayName = displayName;
 0107        }
 108
 109        public bool GetFlag(ITable.Flags flag)
 0110        {
 0111            return m_Flags[(byte)flag];
 0112        }
 113
 114        public void SetFlag(ITable.Flags flag, bool toggle)
 0115        {
 0116            m_Flags[(byte)flag] = toggle;
 0117        }
 118
 119        public ITable.RowDescription[] GetAllRowDescriptions()
 0120        {
 0121            if (combinedColumnCount == 0 || rowCount == 0) return null;
 0122            ITable.RowDescription[] returnArray = new ITable.RowDescription[rowCount];
 0123            string empty = string.Empty;
 0124            for (int i = 0; i < rowCount; i++)
 0125            {
 0126                returnArray[i].InternalIndex = rowDenseIndexToIDMap[i];
 0127                returnArray[i].Name = rowNames[i];
 0128            }
 129
 0130            return returnArray;
 0131        }
 132        public ITable.RowDescription GetRowDescription(string name)
 0133        {
 0134            for (int i = 0; i < rowCount; i++)
 0135            {
 0136                string nameAt = rowNames[i];
 137
 0138                if (nameAt == name)
 0139                {
 0140                    return new ITable.RowDescription
 141                    {
 142                        InternalIndex = rowDenseIndexToIDMap[i],
 143                        Name = nameAt,
 144                    };
 145                }
 0146            }
 147
 0148            throw new ArgumentException("Row with name " + name + " does not exist in the table");
 0149        }
 150
 151        public ITable.RowDescription GetRowDescription(int order)
 0152        {
 0153            return new ITable.RowDescription
 154            {
 155                InternalIndex = rowDenseIndexToIDMap[order],
 156                Name = rowNames[order],
 157            };
 0158        }
 159
 160        public void SetAllRowDescriptionsOrder(ITable.RowDescription[] orderedRows)
 0161        {
 162            // TODO: @adam array coming in be in the new order, just use the internalIndex (stable to reorder inside her
 0163            throw new NotImplementedException();
 164        }
 165
 166        public ITable.ColumnDescription GetColumnDescription(string name)
 0167        {
 0168            for (int i = 0; i < Serializable.SerializableTypesCount; i++)
 0169            {
 0170                string[] columnNames = allColumnNames[i].TArray;
 171
 0172                if (columnNames != null)
 0173                {
 0174                    for (int j = 0; j < columnNames.Length; j++)
 0175                    {
 0176                        string nameAt = columnNames[j];
 177
 0178                        if (name == nameAt)
 0179                        {
 0180                            int columnID = columnDenseIndexToIDMap[i].TArray[j];
 181
 0182                            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[columnID];
 0183                            return new ITable.ColumnDescription
 184                            {
 185                                InternalIndex = columnID,
 186                                Name = nameAt,
 187                                Type = columnEntry.ColumnType,
 188                            };
 189                        }
 0190                    }
 0191                }
 0192            }
 193
 0194            throw new ArgumentException("Column with name " + name + " does not exist in the table");
 0195        }
 196
 197        public ITable.ColumnDescription GetColumnDescription(int order)
 0198        {
 0199            int idAtOrderedIndex = sortedOrderToColumnIDMap[order];
 0200            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[idAtOrderedIndex];
 201
 0202            string columnName = allColumnNames[(int)columnEntry.ColumnType][columnEntry.columnDenseIndex];
 203
 0204            return new ITable.ColumnDescription
 205            {
 206                InternalIndex = idAtOrderedIndex,
 207                Name = columnName,
 208                Type = columnEntry.ColumnType,
 209            };
 0210        }
 211
 212        public void SetAllColumnDescriptionsOrder(ITable.ColumnDescription[] orderedColumns)
 0213        {
 214            // TODO: @adam array coming in be in the new order, just use the internalIndex (stable to reorder inside her
 0215            throw new NotImplementedException();
 216        }
 217
 218        /// <inheritdoc />
 219        public ITable.ColumnDescription[] GetAllColumnDescriptions()
 0220        {
 0221            if (combinedColumnCount == 0) return null;
 0222            ITable.ColumnDescription[] returnArray = new ITable.ColumnDescription[combinedColumnCount];
 223
 0224            for (int i = 0; i < combinedColumnCount; i++)
 0225            {
 0226                int columnID = sortedOrderToColumnIDMap[i];
 0227                AssertColumnIDValid(columnID);
 0228                ref ColumnEntry entryForID = ref columnIDToDenseIndexMap[columnID];
 0229                ref ArrayHolder<string> nameColumnsForType = ref allColumnNames[(int)entryForID.ColumnType];
 230
 0231                string name = nameColumnsForType[entryForID.columnDenseIndex];
 232
 0233                returnArray[i] = new ITable.ColumnDescription
 234                {
 235                    Name = name,
 236                    InternalIndex = columnID,
 237                    Type = entryForID.ColumnType,
 238                };
 0239            }
 240
 0241            return returnArray;
 0242        }
 243
 244        internal void AssertColumnIDValid(int columnID)
 0245        {
 0246            if (columnID < 0 || columnID >= columnIDToDenseIndexMap.Length)
 0247            {
 0248                throw new ArgumentException("Invalid column outside valid ID range: " + columnID);
 249            }
 250
 0251            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[columnID];
 252
 0253            if (columnEntry.ColumnType == Serializable.SerializableTypes.Invalid)
 0254            {
 0255                throw new ArgumentException("Invalid column pointing to deallocated entry: " + columnID);
 256            }
 0257        }
 258
 259        internal void AssertRowIDValid(int rowID)
 0260        {
 0261            if (rowID < 0 || rowID >= rowIDToDenseIndexMap.Length)
 0262            {
 0263                throw new ArgumentException("Invalid row outside valid ID range: " + rowID);
 264            }
 265
 0266            int rowIndex = rowIDToDenseIndexMap[rowID];
 267
 0268            if (rowIndex >= rowCount || rowIndex < 0)
 0269            {
 0270                throw new ArgumentException("Invalid row outside valid ID range: " + rowID);
 271            }
 0272        }
 273
 274        public void SetColumnName(string columnName, int column)
 0275        {
 0276            AssertColumnIDValid(column);
 0277            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[column];
 0278            allColumnNames[(int)columnEntry.ColumnType][columnEntry.columnDenseIndex] = columnName;
 0279        }
 280
 281        public string GetColumnName(int column)
 0282        {
 0283            AssertColumnIDValid(column);
 0284            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[column];
 0285            return allColumnNames[(int)columnEntry.ColumnType][columnEntry.columnDenseIndex];
 0286        }
 287
 288        public void SetRowName(string rowName, int row)
 0289        {
 0290            AssertRowIDValid(row);
 0291            int rowDenseIndex = rowIDToDenseIndexMap[row];
 0292            rowNames[rowDenseIndex] = rowName;
 0293        }
 294
 295        public string GetRowName(int row)
 0296        {
 0297            AssertRowIDValid(row);
 0298            int rowDenseIndex = rowIDToDenseIndexMap[row];
 0299            return rowNames[rowDenseIndex];
 0300        }
 301
 302        public ref string GetRowNameRef(int row)
 0303        {
 0304            AssertRowIDValid(row);
 0305            int rowDenseIndex = rowIDToDenseIndexMap[row];
 0306            return ref rowNames[rowDenseIndex];
 0307        }
 308
 309        public ref string GetColumnNameRef(int columnID)
 0310        {
 0311            AssertColumnIDValid(columnID);
 0312            ref ColumnEntry columnEntry = ref columnIDToDenseIndexMap[columnID];
 0313            return ref allColumnNames[(int)columnEntry.ColumnType][columnEntry.columnDenseIndex];
 0314        }
 315
 316
 317        public int AddRow(string rowName = null, int insertAtRowID = -1)
 0318        {
 0319            if (insertAtRowID >= 0)
 0320            {
 0321                AssertRowIDValid(insertAtRowID);
 0322            }
 0323            int rowID = rowEntriesFreeListHead;
 0324            int rowIDToDenseIndexMapLength = rowIDToDenseIndexMap?.Length ?? 0;
 0325            if (rowID >= rowIDToDenseIndexMapLength)
 0326            {
 0327                int newSize = rowID * 2;
 0328                newSize = newSize == 0 ? 1 : newSize;
 0329                Array.Resize(ref rowIDToDenseIndexMap, newSize);
 0330                for (int i = rowID; i < newSize; i++)
 0331                {
 0332                    rowIDToDenseIndexMap[i] = i + 1;
 0333                }
 0334            }
 335
 0336            int denseIndexToIDMapLength = rowDenseIndexToIDMap?.Length ?? 0;
 0337            Array.Resize(ref rowDenseIndexToIDMap, denseIndexToIDMapLength + 1);
 0338            Array.Resize(ref rowNames, denseIndexToIDMapLength + 1);
 339
 0340            int insertAt = insertAtRowID < 0 ? rowCount : rowIDToDenseIndexMap[insertAtRowID];
 341
 0342            for (int i = denseIndexToIDMapLength; i > insertAt; i--)
 0343            {
 0344                int currentRowID = rowDenseIndexToIDMap[i - 1];
 0345                rowDenseIndexToIDMap[i] = currentRowID;
 346
 0347                rowIDToDenseIndexMap[currentRowID] = i;
 348
 0349                rowNames[i] = rowNames[i - 1];
 0350            }
 351
 0352            rowEntriesFreeListHead = rowIDToDenseIndexMap[rowID];
 0353            rowIDToDenseIndexMap[rowID] = insertAt;
 0354            rowDenseIndexToIDMap[insertAt] = rowID;
 0355            rowNames[insertAt] = rowName == null ? rowID.ToString() : rowName;
 356
 0357            InsertRowsOfTypeInternal(ref allStringColumns, insertAt, 1);
 0358            InsertRowsOfTypeInternal(ref allBoolColumns, insertAt, 1);
 0359            InsertRowsOfTypeInternal(ref allCharColumns, insertAt, 1);
 0360            InsertRowsOfTypeInternal(ref allSbyteColumns, insertAt, 1);
 0361            InsertRowsOfTypeInternal(ref allByteColumns, insertAt, 1);
 0362            InsertRowsOfTypeInternal(ref allShortColumns, insertAt, 1);
 0363            InsertRowsOfTypeInternal(ref allUshortColumns, insertAt, 1);
 0364            InsertRowsOfTypeInternal(ref allIntColumns, insertAt, 1);
 0365            InsertRowsOfTypeInternal(ref allUintColumns, insertAt, 1);
 0366            InsertRowsOfTypeInternal(ref allLongColumns, insertAt, 1);
 0367            InsertRowsOfTypeInternal(ref allUlongColumns, insertAt, 1);
 0368            InsertRowsOfTypeInternal(ref allFloatColumns, insertAt, 1);
 0369            InsertRowsOfTypeInternal(ref allDoubleColumns, insertAt, 1);
 0370            InsertRowsOfTypeInternal(ref allVector2Columns, insertAt, 1);
 0371            InsertRowsOfTypeInternal(ref allVector3Columns, insertAt, 1);
 0372            InsertRowsOfTypeInternal(ref allVector4Columns, insertAt, 1);
 0373            InsertRowsOfTypeInternal(ref allVector2IntColumns, insertAt, 1);
 0374            InsertRowsOfTypeInternal(ref allVector3IntColumns, insertAt, 1);
 0375            InsertRowsOfTypeInternal(ref allQuaternionColumns, insertAt, 1);
 0376            InsertRowsOfTypeInternal(ref allRectColumns, insertAt, 1);
 0377            InsertRowsOfTypeInternal(ref allRectIntColumns, insertAt, 1);
 0378            InsertRowsOfTypeInternal(ref allColorColumns, insertAt, 1);
 0379            InsertRowsOfTypeInternal(ref allLayerMaskColumns, insertAt, 1);
 0380            InsertRowsOfTypeInternal(ref allBoundsColumns, insertAt, 1);
 0381            InsertRowsOfTypeInternal(ref allBoundsIntColumns, insertAt, 1);
 0382            InsertRowsOfTypeInternal(ref allHash128Columns, insertAt, 1);
 0383            InsertRowsOfTypeInternal(ref allGradientColumns, insertAt, 1);
 0384            InsertRowsOfTypeInternal(ref allAnimationCurveColumns, insertAt, 1);
 0385            InsertRowsOfTypeInternal(ref allObjectRefColumns, insertAt, 1);
 386
 0387            ++rowCount;
 0388            dataVersion++;
 389
 0390            return rowID;
 0391        }
 392
 393        public void AddRows(int numberOfNewRows, string[] rowNames = null, int insertAtRowID = -1)
 0394        {
 0395            if (insertAtRowID >= 0)
 0396            {
 0397                AssertRowIDValid(insertAtRowID);
 0398            }
 0399            int rowIDToDenseIndexMapLength = rowIDToDenseIndexMap?.Length ?? 0;
 0400            int newCount = rowCount + numberOfNewRows;
 0401            if (newCount > rowIDToDenseIndexMapLength)
 0402            {
 0403                int newSize = newCount;
 0404                --newSize;
 0405                newSize |= newSize >> 1;
 0406                newSize |= newSize >> 2;
 0407                newSize |= newSize >> 4;
 0408                newSize |= newSize >> 8;
 0409                newSize |= newSize >> 16;
 0410                ++newSize;
 411
 0412                newSize = newSize == 0 ? 1 : newSize;
 0413                Array.Resize(ref rowIDToDenseIndexMap, newSize);
 0414                for (int i = rowIDToDenseIndexMapLength; i < newSize; i++)
 0415                {
 0416                    rowIDToDenseIndexMap[i] = i + 1;
 0417                }
 0418            }
 419
 0420            int denseIndexToIDMapLength = rowDenseIndexToIDMap?.Length ?? 0;
 0421            Array.Resize(ref rowDenseIndexToIDMap, denseIndexToIDMapLength + numberOfNewRows);
 0422            Array.Resize(ref rowNames, denseIndexToIDMapLength + numberOfNewRows);
 423
 0424            int insertAt = insertAtRowID < 0 ? rowCount : rowIDToDenseIndexMap[insertAtRowID];
 425
 0426            for (int i = denseIndexToIDMapLength; i > insertAt + numberOfNewRows - 1; i--)
 0427            {
 0428                int currentRowID = rowDenseIndexToIDMap[i - numberOfNewRows];
 0429                rowDenseIndexToIDMap[i] = currentRowID;
 430
 0431                rowIDToDenseIndexMap[currentRowID] = i;
 432
 0433                rowNames[i] = rowNames[i - numberOfNewRows];
 0434            }
 435
 0436            int freeListHead = rowEntriesFreeListHead;
 437
 0438            for (int i = 0; i < numberOfNewRows; i++)
 0439            {
 0440                int rowID = freeListHead;
 0441                freeListHead = rowIDToDenseIndexMap[rowID];
 0442                rowIDToDenseIndexMap[rowID] = insertAt + i;
 0443                rowDenseIndexToIDMap[insertAt + i] = rowID;
 0444            }
 445
 0446            int numberOfNewRowNames = rowNames?.Length ?? 0;
 0447            string emptyString = string.Empty;
 0448            for (int i = 0; i < numberOfNewRowNames; i++)
 0449            {
 0450                string currentRowName = rowNames[i];
 0451                int rowIDAt = rowDenseIndexToIDMap[insertAt + i];
 0452                rowNames[insertAt + i] = currentRowName == null ? rowIDAt.ToString() : currentRowName;
 0453            }
 454
 0455            for (int i = numberOfNewRowNames; i < numberOfNewRows; i++)
 0456            {
 0457                int rowIDAt = rowDenseIndexToIDMap[insertAt + i];
 0458                rowNames[insertAt + i] = rowIDAt.ToString();
 0459            }
 460
 0461            rowEntriesFreeListHead = freeListHead;
 462
 0463            InsertRowsOfTypeInternal(ref allStringColumns, insertAt, numberOfNewRows);
 0464            InsertRowsOfTypeInternal(ref allBoolColumns, insertAt, numberOfNewRows);
 0465            InsertRowsOfTypeInternal(ref allCharColumns, insertAt, numberOfNewRows);
 0466            InsertRowsOfTypeInternal(ref allSbyteColumns, insertAt, numberOfNewRows);
 0467            InsertRowsOfTypeInternal(ref allByteColumns, insertAt, numberOfNewRows);
 0468            InsertRowsOfTypeInternal(ref allShortColumns, insertAt, numberOfNewRows);
 0469            InsertRowsOfTypeInternal(ref allUshortColumns, insertAt, numberOfNewRows);
 0470            InsertRowsOfTypeInternal(ref allIntColumns, insertAt, numberOfNewRows);
 0471            InsertRowsOfTypeInternal(ref allUintColumns, insertAt, numberOfNewRows);
 0472            InsertRowsOfTypeInternal(ref allLongColumns, insertAt, numberOfNewRows);
 0473            InsertRowsOfTypeInternal(ref allUlongColumns, insertAt, numberOfNewRows);
 0474            InsertRowsOfTypeInternal(ref allFloatColumns, insertAt, numberOfNewRows);
 0475            InsertRowsOfTypeInternal(ref allDoubleColumns, insertAt, numberOfNewRows);
 0476            InsertRowsOfTypeInternal(ref allVector2Columns, insertAt, numberOfNewRows);
 0477            InsertRowsOfTypeInternal(ref allVector3Columns, insertAt, numberOfNewRows);
 0478            InsertRowsOfTypeInternal(ref allVector4Columns, insertAt, numberOfNewRows);
 0479            InsertRowsOfTypeInternal(ref allVector2IntColumns, insertAt, numberOfNewRows);
 0480            InsertRowsOfTypeInternal(ref allVector3IntColumns, insertAt, numberOfNewRows);
 0481            InsertRowsOfTypeInternal(ref allQuaternionColumns, insertAt, numberOfNewRows);
 0482            InsertRowsOfTypeInternal(ref allRectColumns, insertAt, numberOfNewRows);
 0483            InsertRowsOfTypeInternal(ref allRectIntColumns, insertAt, numberOfNewRows);
 0484            InsertRowsOfTypeInternal(ref allColorColumns, insertAt, numberOfNewRows);
 0485            InsertRowsOfTypeInternal(ref allLayerMaskColumns, insertAt, numberOfNewRows);
 0486            InsertRowsOfTypeInternal(ref allBoundsColumns, insertAt, numberOfNewRows);
 0487            InsertRowsOfTypeInternal(ref allBoundsIntColumns, insertAt, numberOfNewRows);
 0488            InsertRowsOfTypeInternal(ref allHash128Columns, insertAt, numberOfNewRows);
 0489            InsertRowsOfTypeInternal(ref allGradientColumns, insertAt, numberOfNewRows);
 0490            InsertRowsOfTypeInternal(ref allAnimationCurveColumns, insertAt, numberOfNewRows);
 0491            InsertRowsOfTypeInternal(ref allObjectRefColumns, insertAt, numberOfNewRows);
 492
 0493            rowCount += numberOfNewRows;
 0494            dataVersion++;
 0495        }
 496
 497        public void AddRows(int numberOfNewRows, ref int[] rowIDs, string[] rowNames = null, int insertAtRowID = -1)
 0498        {
 0499            if (insertAtRowID >= 0)
 0500            {
 0501                AssertRowIDValid(insertAtRowID);
 0502            }
 0503            int rowIDToDenseIndexMapLength = rowIDToDenseIndexMap?.Length ?? 0;
 0504            int newCount = rowCount + numberOfNewRows;
 0505            if (newCount > rowIDToDenseIndexMapLength)
 0506            {
 0507                int newSize = newCount;
 0508                --newSize;
 0509                newSize |= newSize >> 1;
 0510                newSize |= newSize >> 2;
 0511                newSize |= newSize >> 4;
 0512                newSize |= newSize >> 8;
 0513                newSize |= newSize >> 16;
 0514                ++newSize;
 515
 0516                newSize = newSize == 0 ? 1 : newSize;
 0517                Array.Resize(ref rowIDToDenseIndexMap, newSize);
 0518                for (int i = rowIDToDenseIndexMapLength; i < newSize; i++)
 0519                {
 0520                    rowIDToDenseIndexMap[i] = i + 1;
 0521                }
 0522            }
 523
 0524            int denseIndexToIDMapLength = rowDenseIndexToIDMap?.Length ?? 0;
 0525            Array.Resize(ref rowDenseIndexToIDMap, denseIndexToIDMapLength + numberOfNewRows);
 526
 0527            int insertAt = insertAtRowID < 0 ? rowCount : rowIDToDenseIndexMap[insertAtRowID];
 528
 0529            for (int i = denseIndexToIDMapLength; i > insertAt + numberOfNewRows - 1; i--)
 0530            {
 0531                int currentRowID = rowDenseIndexToIDMap[i - numberOfNewRows];
 0532                rowDenseIndexToIDMap[i] = currentRowID;
 533
 0534                rowIDToDenseIndexMap[currentRowID] = i;
 535
 0536                rowNames[i] = rowNames[i - numberOfNewRows];
 0537            }
 538
 0539            int freeListHead = rowEntriesFreeListHead;
 540
 0541            for (int i = 0; i < numberOfNewRows; i++)
 0542            {
 0543                int rowID = freeListHead;
 0544                freeListHead = rowIDToDenseIndexMap[rowID];
 0545                rowIDToDenseIndexMap[rowID] = insertAt + i;
 0546                rowDenseIndexToIDMap[insertAt + i] = rowID;
 0547                rowIDs[i] = rowID;
 0548            }
 549
 0550            int numberOfNewRowNames = rowNames?.Length ?? 0;
 0551            for (int i = 0; i < numberOfNewRowNames; i++)
 0552            {
 0553                string currentRowName = rowNames[i];
 0554                int rowIDAt = rowDenseIndexToIDMap[insertAt + i];
 0555                rowNames[insertAt + i] = currentRowName == null ? rowIDAt.ToString() : currentRowName;
 0556            }
 557
 0558            for (int i = numberOfNewRowNames; i < numberOfNewRows; i++)
 0559            {
 0560                int rowIDAt = rowDenseIndexToIDMap[insertAt + i];
 0561                rowNames[insertAt + i] = rowIDAt.ToString();
 0562            }
 563
 0564            rowEntriesFreeListHead = freeListHead;
 565
 0566            InsertRowsOfTypeInternal(ref allStringColumns, insertAt, numberOfNewRows);
 0567            InsertRowsOfTypeInternal(ref allBoolColumns, insertAt, numberOfNewRows);
 0568            InsertRowsOfTypeInternal(ref allCharColumns, insertAt, numberOfNewRows);
 0569            InsertRowsOfTypeInternal(ref allSbyteColumns, insertAt, numberOfNewRows);
 0570            InsertRowsOfTypeInternal(ref allByteColumns, insertAt, numberOfNewRows);
 0571            InsertRowsOfTypeInternal(ref allShortColumns, insertAt, numberOfNewRows);
 0572            InsertRowsOfTypeInternal(ref allUshortColumns, insertAt, numberOfNewRows);
 0573            InsertRowsOfTypeInternal(ref allIntColumns, insertAt, numberOfNewRows);
 0574            InsertRowsOfTypeInternal(ref allUintColumns, insertAt, numberOfNewRows);
 0575            InsertRowsOfTypeInternal(ref allLongColumns, insertAt, numberOfNewRows);
 0576            InsertRowsOfTypeInternal(ref allUlongColumns, insertAt, numberOfNewRows);
 0577            InsertRowsOfTypeInternal(ref allFloatColumns, insertAt, numberOfNewRows);
 0578            InsertRowsOfTypeInternal(ref allDoubleColumns, insertAt, numberOfNewRows);
 0579            InsertRowsOfTypeInternal(ref allVector2Columns, insertAt, numberOfNewRows);
 0580            InsertRowsOfTypeInternal(ref allVector3Columns, insertAt, numberOfNewRows);
 0581            InsertRowsOfTypeInternal(ref allVector4Columns, insertAt, numberOfNewRows);
 0582            InsertRowsOfTypeInternal(ref allVector2IntColumns, insertAt, numberOfNewRows);
 0583            InsertRowsOfTypeInternal(ref allVector3IntColumns, insertAt, numberOfNewRows);
 0584            InsertRowsOfTypeInternal(ref allQuaternionColumns, insertAt, numberOfNewRows);
 0585            InsertRowsOfTypeInternal(ref allRectColumns, insertAt, numberOfNewRows);
 0586            InsertRowsOfTypeInternal(ref allRectIntColumns, insertAt, numberOfNewRows);
 0587            InsertRowsOfTypeInternal(ref allColorColumns, insertAt, numberOfNewRows);
 0588            InsertRowsOfTypeInternal(ref allLayerMaskColumns, insertAt, numberOfNewRows);
 0589            InsertRowsOfTypeInternal(ref allBoundsColumns, insertAt, numberOfNewRows);
 0590            InsertRowsOfTypeInternal(ref allBoundsIntColumns, insertAt, numberOfNewRows);
 0591            InsertRowsOfTypeInternal(ref allHash128Columns, insertAt, numberOfNewRows);
 0592            InsertRowsOfTypeInternal(ref allGradientColumns, insertAt, numberOfNewRows);
 0593            InsertRowsOfTypeInternal(ref allAnimationCurveColumns, insertAt, numberOfNewRows);
 0594            InsertRowsOfTypeInternal(ref allObjectRefColumns, insertAt, numberOfNewRows);
 595
 0596            rowCount += numberOfNewRows;
 0597            dataVersion++;
 0598        }
 599
 600        public void RemoveRow(int rowID)
 0601        {
 0602            AssertRowIDValid(rowID);
 0603            int rowDenseIndex = rowIDToDenseIndexMap[rowID];
 0604            for (int i = rowDenseIndex + 1; i < rowCount; i++)
 0605            {
 0606                int currentRowID = rowDenseIndexToIDMap[i];
 0607                rowIDToDenseIndexMap[currentRowID] = i - 1;
 0608                rowDenseIndexToIDMap[i - 1] = currentRowID;
 0609                rowNames[i - 1] = rowNames[i];
 0610            }
 611
 0612            rowIDToDenseIndexMap[rowID] = rowEntriesFreeListHead;
 0613            rowEntriesFreeListHead = rowID;
 0614            Array.Resize(ref rowDenseIndexToIDMap, rowCount - 1);
 0615            Array.Resize(ref rowNames, rowCount - 1);
 616
 0617            DeleteRowsOfTypeInternal(ref allStringColumns, rowID, 1);
 0618            DeleteRowsOfTypeInternal(ref allBoolColumns, rowID, 1);
 0619            DeleteRowsOfTypeInternal(ref allCharColumns, rowID, 1);
 0620            DeleteRowsOfTypeInternal(ref allSbyteColumns, rowID, 1);
 0621            DeleteRowsOfTypeInternal(ref allByteColumns, rowID, 1);
 0622            DeleteRowsOfTypeInternal(ref allShortColumns, rowID, 1);
 0623            DeleteRowsOfTypeInternal(ref allUshortColumns, rowID, 1);
 0624            DeleteRowsOfTypeInternal(ref allIntColumns, rowID, 1);
 0625            DeleteRowsOfTypeInternal(ref allUintColumns, rowID, 1);
 0626            DeleteRowsOfTypeInternal(ref allLongColumns, rowID, 1);
 0627            DeleteRowsOfTypeInternal(ref allUlongColumns, rowID, 1);
 0628            DeleteRowsOfTypeInternal(ref allFloatColumns, rowID, 1);
 0629            DeleteRowsOfTypeInternal(ref allDoubleColumns, rowID, 1);
 0630            DeleteRowsOfTypeInternal(ref allVector2Columns, rowID, 1);
 0631            DeleteRowsOfTypeInternal(ref allVector3Columns, rowID, 1);
 0632            DeleteRowsOfTypeInternal(ref allVector4Columns, rowID, 1);
 0633            DeleteRowsOfTypeInternal(ref allVector2IntColumns, rowID, 1);
 0634            DeleteRowsOfTypeInternal(ref allVector3IntColumns, rowID, 1);
 0635            DeleteRowsOfTypeInternal(ref allQuaternionColumns, rowID, 1);
 0636            DeleteRowsOfTypeInternal(ref allRectColumns, rowID, 1);
 0637            DeleteRowsOfTypeInternal(ref allRectIntColumns, rowID, 1);
 0638            DeleteRowsOfTypeInternal(ref allColorColumns, rowID, 1);
 0639            DeleteRowsOfTypeInternal(ref allLayerMaskColumns, rowID, 1);
 0640            DeleteRowsOfTypeInternal(ref allBoundsColumns, rowID, 1);
 0641            DeleteRowsOfTypeInternal(ref allBoundsIntColumns, rowID, 1);
 0642            DeleteRowsOfTypeInternal(ref allHash128Columns, rowID, 1);
 0643            DeleteRowsOfTypeInternal(ref allGradientColumns, rowID, 1);
 0644            DeleteRowsOfTypeInternal(ref allAnimationCurveColumns, rowID, 1);
 0645            DeleteRowsOfTypeInternal(ref allObjectRefColumns, rowID, 1);
 646
 0647            --rowCount;
 0648            dataVersion++;
 0649        }
 650
 651        public int AddColumn(Serializable.SerializableTypes columnType, string columnName, int insertAtColumnID = -1)
 0652        {
 0653            switch (columnType)
 654            {
 655                case Serializable.SerializableTypes.String:
 0656                    return AddColumnInternal(columnName, ref allStringColumns, Serializable.SerializableTypes.String, in
 657                case Serializable.SerializableTypes.Char:
 0658                    return AddColumnInternal(columnName, ref allCharColumns, Serializable.SerializableTypes.Char, insert
 659                case Serializable.SerializableTypes.Bool:
 0660                    return AddColumnInternal(columnName, ref allBoolColumns, Serializable.SerializableTypes.Bool, insert
 661                case Serializable.SerializableTypes.SByte:
 0662                    return AddColumnInternal(columnName, ref allSbyteColumns, Serializable.SerializableTypes.SByte, inse
 663                case Serializable.SerializableTypes.Byte:
 0664                    return AddColumnInternal(columnName, ref allByteColumns, Serializable.SerializableTypes.Byte, insert
 665                case Serializable.SerializableTypes.Short:
 0666                    return AddColumnInternal(columnName, ref allShortColumns, Serializable.SerializableTypes.Short, inse
 667                case Serializable.SerializableTypes.UShort:
 0668                    return AddColumnInternal(columnName, ref allUshortColumns, Serializable.SerializableTypes.UShort, in
 669                case Serializable.SerializableTypes.Int:
 0670                    return AddColumnInternal(columnName, ref allIntColumns, Serializable.SerializableTypes.Int, insertAt
 671                case Serializable.SerializableTypes.UInt:
 0672                    return AddColumnInternal(columnName, ref allUintColumns, Serializable.SerializableTypes.UInt, insert
 673                case Serializable.SerializableTypes.Long:
 0674                    return AddColumnInternal(columnName, ref allLongColumns, Serializable.SerializableTypes.Long, insert
 675                case Serializable.SerializableTypes.ULong:
 0676                    return AddColumnInternal(columnName, ref allUlongColumns, Serializable.SerializableTypes.ULong, inse
 677                case Serializable.SerializableTypes.Float:
 0678                    return AddColumnInternal(columnName, ref allFloatColumns, Serializable.SerializableTypes.Float, inse
 679                case Serializable.SerializableTypes.Double:
 0680                    return AddColumnInternal(columnName, ref allDoubleColumns, Serializable.SerializableTypes.Double, in
 681                case Serializable.SerializableTypes.Vector2:
 0682                    return AddColumnInternal(columnName, ref allVector2Columns, Serializable.SerializableTypes.Vector2, 
 683                case Serializable.SerializableTypes.Vector3:
 0684                    return AddColumnInternal(columnName, ref allVector3Columns, Serializable.SerializableTypes.Vector3, 
 685                case Serializable.SerializableTypes.Vector4:
 0686                    return AddColumnInternal(columnName, ref allVector4Columns, Serializable.SerializableTypes.Vector4, 
 687                case Serializable.SerializableTypes.Vector2Int:
 0688                    return AddColumnInternal(columnName, ref allVector2IntColumns, Serializable.SerializableTypes.Vector
 689                case Serializable.SerializableTypes.Vector3Int:
 0690                    return AddColumnInternal(columnName, ref allVector3IntColumns, Serializable.SerializableTypes.Vector
 691                case Serializable.SerializableTypes.Quaternion:
 0692                    return AddColumnInternal(columnName, ref allQuaternionColumns, Serializable.SerializableTypes.Quater
 693                case Serializable.SerializableTypes.Rect:
 0694                    return AddColumnInternal(columnName, ref allRectColumns, Serializable.SerializableTypes.Rect, insert
 695                case Serializable.SerializableTypes.RectInt:
 0696                    return AddColumnInternal(columnName, ref allRectIntColumns, Serializable.SerializableTypes.RectInt, 
 697                case Serializable.SerializableTypes.Color:
 0698                    return AddColumnInternal(columnName, ref allColorColumns, Serializable.SerializableTypes.Color, inse
 699                case Serializable.SerializableTypes.LayerMask:
 0700                    return AddColumnInternal(columnName, ref allLayerMaskColumns, Serializable.SerializableTypes.LayerMa
 701                case Serializable.SerializableTypes.Bounds:
 0702                    return AddColumnInternal(columnName, ref allBoundsColumns, Serializable.SerializableTypes.Bounds, in
 703                case Serializable.SerializableTypes.BoundsInt:
 0704                    return AddColumnInternal(columnName, ref allBoundsIntColumns, Serializable.SerializableTypes.BoundsI
 705                case Serializable.SerializableTypes.Hash128:
 0706                    return AddColumnInternal(columnName, ref allHash128Columns, Serializable.SerializableTypes.Hash128, 
 707                case Serializable.SerializableTypes.Gradient:
 0708                    return AddColumnInternal(columnName, ref allGradientColumns, Serializable.SerializableTypes.Gradient
 709                case Serializable.SerializableTypes.AnimationCurve:
 0710                    return AddColumnInternal(columnName, ref allAnimationCurveColumns, Serializable.SerializableTypes.An
 711                case Serializable.SerializableTypes.Object:
 0712                    return AddColumnInternal(columnName, ref allObjectRefColumns, Serializable.SerializableTypes.Object,
 713            }
 0714            return -1;
 0715        }
 716
 717        public void RemoveColumn(Serializable.SerializableTypes columnType, int columnID)
 0718        {
 0719            switch (columnType)
 720            {
 721                case Serializable.SerializableTypes.String:
 0722                    RemoveColumnInternal(ref allStringColumns, Serializable.SerializableTypes.String, columnID);
 0723                    break;
 724                case Serializable.SerializableTypes.Char:
 0725                    RemoveColumnInternal(ref allCharColumns, Serializable.SerializableTypes.Char, columnID);
 0726                    break;
 727                case Serializable.SerializableTypes.Bool:
 0728                    RemoveColumnInternal(ref allBoolColumns, Serializable.SerializableTypes.Bool, columnID);
 0729                    break;
 730                case Serializable.SerializableTypes.SByte:
 0731                    RemoveColumnInternal(ref allSbyteColumns, Serializable.SerializableTypes.SByte, columnID);
 0732                    break;
 733                case Serializable.SerializableTypes.Byte:
 0734                    RemoveColumnInternal(ref allByteColumns, Serializable.SerializableTypes.Byte, columnID);
 0735                    break;
 736                case Serializable.SerializableTypes.Short:
 0737                    RemoveColumnInternal(ref allShortColumns, Serializable.SerializableTypes.Short, columnID);
 0738                    break;
 739                case Serializable.SerializableTypes.UShort:
 0740                    RemoveColumnInternal(ref allUshortColumns, Serializable.SerializableTypes.UShort, columnID);
 0741                    break;
 742                case Serializable.SerializableTypes.Int:
 0743                    RemoveColumnInternal(ref allIntColumns, Serializable.SerializableTypes.Int, columnID);
 0744                    break;
 745                case Serializable.SerializableTypes.UInt:
 0746                    RemoveColumnInternal(ref allUintColumns, Serializable.SerializableTypes.UInt, columnID);
 0747                    break;
 748                case Serializable.SerializableTypes.Long:
 0749                    RemoveColumnInternal(ref allLongColumns, Serializable.SerializableTypes.Long, columnID);
 0750                    break;
 751                case Serializable.SerializableTypes.ULong:
 0752                    RemoveColumnInternal(ref allUlongColumns, Serializable.SerializableTypes.ULong, columnID);
 0753                    break;
 754                case Serializable.SerializableTypes.Float:
 0755                    RemoveColumnInternal(ref allFloatColumns, Serializable.SerializableTypes.Float, columnID);
 0756                    break;
 757                case Serializable.SerializableTypes.Double:
 0758                    RemoveColumnInternal(ref allDoubleColumns, Serializable.SerializableTypes.Double, columnID);
 0759                    break;
 760                case Serializable.SerializableTypes.Vector2:
 0761                    RemoveColumnInternal(ref allVector2Columns, Serializable.SerializableTypes.Vector2, columnID);
 0762                    break;
 763                case Serializable.SerializableTypes.Vector3:
 0764                    RemoveColumnInternal(ref allVector3Columns, Serializable.SerializableTypes.Vector3, columnID);
 0765                    break;
 766                case Serializable.SerializableTypes.Vector4:
 0767                    RemoveColumnInternal(ref allVector4Columns, Serializable.SerializableTypes.Vector4, columnID);
 0768                    break;
 769                case Serializable.SerializableTypes.Vector2Int:
 0770                    RemoveColumnInternal(ref allVector2IntColumns, Serializable.SerializableTypes.Vector2Int, columnID);
 0771                    break;
 772                case Serializable.SerializableTypes.Vector3Int:
 0773                    RemoveColumnInternal(ref allVector3IntColumns, Serializable.SerializableTypes.Vector3Int, columnID);
 0774                    break;
 775                case Serializable.SerializableTypes.Quaternion:
 0776                    RemoveColumnInternal(ref allQuaternionColumns, Serializable.SerializableTypes.Quaternion, columnID);
 0777                    break;
 778                case Serializable.SerializableTypes.Rect:
 0779                    RemoveColumnInternal(ref allRectColumns, Serializable.SerializableTypes.Rect, columnID);
 0780                    break;
 781                case Serializable.SerializableTypes.RectInt:
 0782                    RemoveColumnInternal(ref allRectIntColumns, Serializable.SerializableTypes.RectInt, columnID);
 0783                    break;
 784                case Serializable.SerializableTypes.Color:
 0785                    RemoveColumnInternal(ref allColorColumns, Serializable.SerializableTypes.Color, columnID);
 0786                    break;
 787                case Serializable.SerializableTypes.LayerMask:
 0788                    RemoveColumnInternal(ref allLayerMaskColumns, Serializable.SerializableTypes.LayerMask, columnID);
 0789                    break;
 790                case Serializable.SerializableTypes.Bounds:
 0791                    RemoveColumnInternal(ref allBoundsColumns, Serializable.SerializableTypes.Bounds, columnID);
 0792                    break;
 793                case Serializable.SerializableTypes.BoundsInt:
 0794                    RemoveColumnInternal(ref allBoundsIntColumns, Serializable.SerializableTypes.BoundsInt, columnID);
 0795                    break;
 796                case Serializable.SerializableTypes.Hash128:
 0797                    RemoveColumnInternal(ref allHash128Columns, Serializable.SerializableTypes.Hash128, columnID);
 0798                    break;
 799                case Serializable.SerializableTypes.Gradient:
 0800                    RemoveColumnInternal(ref allGradientColumns, Serializable.SerializableTypes.Gradient, columnID);
 0801                    break;
 802                case Serializable.SerializableTypes.AnimationCurve:
 0803                    RemoveColumnInternal(ref allAnimationCurveColumns, Serializable.SerializableTypes.AnimationCurve, co
 0804                    break;
 805                case Serializable.SerializableTypes.Object:
 0806                    RemoveColumnInternal(ref allObjectRefColumns, Serializable.SerializableTypes.Object, columnID);
 0807                    break;
 808            }
 0809        }
 810
 811        // Set
 812
 813        public ulong SetString(int row, int column, string value)
 0814        {
 0815            return SetCell(row, column, ref allStringColumns, value);
 0816        }
 817
 818        public ulong SetBool(int row, int column, bool value)
 0819        {
 0820            return SetCell(row, column, ref allBoolColumns, value);
 0821        }
 822
 823        public ulong SetChar(int row, int column, char value)
 0824        {
 0825            return SetCell(row, column, ref allCharColumns, value);
 0826        }
 827
 828        public ulong SetSByte(int row, int column, sbyte value)
 0829        {
 0830            return SetCell(row, column, ref allSbyteColumns, value);
 0831        }
 832
 833        public ulong SetByte(int row, int column, byte value)
 0834        {
 0835            return SetCell(row, column, ref allByteColumns, value);
 0836        }
 837
 838        public ulong SetShort(int row, int column, short value)
 0839        {
 0840            return SetCell(row, column, ref allShortColumns, value);
 0841        }
 842
 843        public ulong SetUShort(int row, int column, ushort value)
 0844        {
 0845            return SetCell(row, column, ref allUshortColumns, value);
 0846        }
 847
 848        public ulong SetInt(int row, int column, int value)
 0849        {
 0850            return SetCell(row, column, ref allIntColumns, value);
 0851        }
 852
 853        public ulong SetUInt(int row, int column, uint value)
 0854        {
 0855            return SetCell(row, column, ref allUintColumns, value);
 0856        }
 857
 858        public ulong SetLong(int row, int column, long value)
 0859        {
 0860            return SetCell(row, column, ref allLongColumns, value);
 0861        }
 862
 863        public ulong SetULong(int row, int column, ulong value)
 0864        {
 0865            return SetCell(row, column, ref allUlongColumns, value);
 0866        }
 867
 868        public ulong SetFloat(int row, int column, float value)
 0869        {
 0870            return SetCell(row, column, ref allFloatColumns, value);
 0871        }
 872
 873        public ulong SetDouble(int row, int column, double value)
 0874        {
 0875            return SetCell(row, column, ref allDoubleColumns, value);
 0876        }
 877
 878        public ulong SetVector2(int row, int column, Vector2 value)
 0879        {
 0880            return SetCell(row, column, ref allVector2Columns, value);
 0881        }
 882
 883        public ulong SetVector3(int row, int column, Vector3 value)
 0884        {
 0885            return SetCell(row, column, ref allVector3Columns, value);
 0886        }
 887
 888        public ulong SetVector4(int row, int column, Vector4 value)
 0889        {
 0890            return SetCell(row, column, ref allVector4Columns, value);
 0891        }
 892
 893        public ulong SetVector2Int(int row, int column, Vector2Int value)
 0894        {
 0895            return SetCell(row, column, ref allVector2IntColumns, value);
 0896        }
 897
 898        public ulong SetVector3Int(int row, int column, Vector3Int value)
 0899        {
 0900            return SetCell(row, column, ref allVector3IntColumns, value);
 0901        }
 902
 903        public ulong SetQuaternion(int row, int column, Quaternion value)
 0904        {
 0905            return SetCell(row, column, ref allQuaternionColumns, value);
 0906        }
 907
 908        public ulong SetRect(int row, int column, Rect value)
 0909        {
 0910            return SetCell(row, column, ref allRectColumns, value);
 0911        }
 912
 913        public ulong SetRectInt(int row, int column, RectInt value)
 0914        {
 0915            return SetCell(row, column, ref allRectIntColumns, value);
 0916        }
 917
 918        public ulong SetColor(int row, int column, Color value)
 0919        {
 0920            return SetCell(row, column, ref allColorColumns, value);
 0921        }
 922
 923        public ulong SetLayerMask(int row, int column, LayerMask value)
 0924        {
 0925            return SetCell(row, column, ref allLayerMaskColumns, value);
 0926        }
 927
 928        public ulong SetBounds(int row, int column, Bounds value)
 0929        {
 0930            return SetCell(row, column, ref allBoundsColumns, value);
 0931        }
 932
 933        public ulong SetBoundsInt(int row, int column, BoundsInt value)
 0934        {
 0935            return SetCell(row, column, ref allBoundsIntColumns, value);
 0936        }
 937
 938        public ulong SetHash128(int row, int column, Hash128 value)
 0939        {
 0940            return SetCell(row, column, ref allHash128Columns, value);
 0941        }
 942
 943        public ulong SetGradient(int row, int column, Gradient value)
 0944        {
 0945            return SetCell(row, column, ref allGradientColumns, value);
 0946        }
 947
 948        public ulong SetAnimationCurve(int row, int column, AnimationCurve value)
 0949        {
 0950            return SetCell(row, column, ref allAnimationCurveColumns, value);
 0951        }
 952
 953        public ulong SetObject(int row, int column, UnityEngine.Object value)
 0954        {
 0955            return SetCell(row, column, ref allObjectRefColumns, value);
 0956        }
 957
 958        // Get
 959        public string GetString(int row, int column)
 0960        {
 0961            return GetCell(row, column, ref allStringColumns);
 0962        }
 963
 964        public bool GetBool(int row, int column)
 0965        {
 0966            return GetCell(row, column, ref allBoolColumns);
 0967        }
 968
 969        public char GetChar(int row, int column)
 0970        {
 0971            return GetCell(row, column, ref allCharColumns);
 0972        }
 973
 974        public sbyte GetSByte(int row, int column)
 0975        {
 0976            return GetCell(row, column, ref allSbyteColumns);
 0977        }
 978
 979        public byte GetByte(int row, int column)
 0980        {
 0981            return GetCell(row, column, ref allByteColumns);
 0982        }
 983
 984        public short GetShort(int row, int column)
 0985        {
 0986            return GetCell(row, column, ref allShortColumns);
 0987        }
 988
 989        public ushort GetUShort(int row, int column)
 0990        {
 0991            return GetCell(row, column, ref allUshortColumns);
 0992        }
 993
 994        public int GetInt(int row, int column)
 0995        {
 0996            return GetCell(row, column, ref allIntColumns);
 0997        }
 998
 999        public uint GetUInt(int row, int column)
 01000        {
 01001            return GetCell(row, column, ref allUintColumns);
 01002        }
 1003
 1004        public long GetLong(int row, int column)
 01005        {
 01006            return GetCell(row, column, ref allLongColumns);
 01007        }
 1008
 1009        public ulong GetULong(int row, int column)
 01010        {
 01011            return GetCell(row, column, ref allUlongColumns);
 01012        }
 1013
 1014        public float GetFloat(int row, int column)
 01015        {
 01016            return GetCell(row, column, ref allFloatColumns);
 01017        }
 1018
 1019        public double GetDouble(int row, int column)
 01020        {
 01021            return GetCell(row, column, ref allDoubleColumns);
 01022        }
 1023
 1024        public Vector2 GetVector2(int row, int column)
 01025        {
 01026            return GetCell(row, column, ref allVector2Columns);
 01027        }
 1028
 1029        public Vector3 GetVector3(int row, int column)
 01030        {
 01031            return GetCell(row, column, ref allVector3Columns);
 01032        }
 1033
 1034        public Vector4 GetVector4(int row, int column)
 01035        {
 01036            return GetCell(row, column, ref allVector4Columns);
 01037        }
 1038
 1039        public Vector2Int GetVector2Int(int row, int column)
 01040        {
 01041            return GetCell(row, column, ref allVector2IntColumns);
 01042        }
 1043
 1044        public Vector3Int GetVector3Int(int row, int column)
 01045        {
 01046            return GetCell(row, column, ref allVector3IntColumns);
 01047        }
 1048
 1049        public Quaternion GetQuaternion(int row, int column)
 01050        {
 01051            return GetCell(row, column, ref allQuaternionColumns);
 01052        }
 1053
 1054        public Rect GetRect(int row, int column)
 01055        {
 01056            return GetCell(row, column, ref allRectColumns);
 01057        }
 1058
 1059        public RectInt GetRectInt(int row, int column)
 01060        {
 01061            return GetCell(row, column, ref allRectIntColumns);
 01062        }
 1063
 1064        public Color GetColor(int row, int column)
 01065        {
 01066            return GetCell(row, column, ref allColorColumns);
 01067        }
 1068
 1069        public LayerMask GetLayerMask(int row, int column)
 01070        {
 01071            return GetCell(row, column, ref allLayerMaskColumns);
 01072        }
 1073
 1074        public Bounds GetBounds(int row, int column)
 01075        {
 01076            return GetCell(row, column, ref allBoundsColumns);
 01077        }
 1078
 1079        public BoundsInt GetBoundsInt(int row, int column)
 01080        {
 01081            return GetCell(row, column, ref allBoundsIntColumns);
 01082        }
 1083
 1084        public Hash128 GetHash128(int row, int column)
 01085        {
 01086            return GetCell(row, column, ref allHash128Columns);
 01087        }
 1088
 1089        public Gradient GetGradient(int row, int column)
 01090        {
 01091            return GetCell(row, column, ref allGradientColumns);
 01092        }
 1093
 1094        public AnimationCurve GetAnimationCurve(int row, int column)
 01095        {
 01096            return GetCell(row, column, ref allAnimationCurveColumns);
 01097        }
 1098
 1099        public UnityEngine.Object GetObject(int row, int column)
 01100        {
 01101            return GetCell(row, column, ref allObjectRefColumns);
 01102        }
 1103
 1104        // Get ref
 1105
 1106        public ref string GetStringRef(int row, int column)
 01107        {
 01108            return ref GetCellRef(row, column, ref allStringColumns);
 01109        }
 1110
 1111        public ref bool GetBoolRef(int row, int column)
 01112        {
 01113            return ref GetCellRef(row, column, ref allBoolColumns);
 01114        }
 1115
 1116        public ref char GetCharRef(int row, int column)
 01117        {
 01118            return ref GetCellRef(row, column, ref allCharColumns);
 01119        }
 1120
 1121        public ref sbyte GetSbyteRef(int row, int column)
 01122        {
 01123            return ref GetCellRef(row, column, ref allSbyteColumns);
 01124        }
 1125
 1126        public ref byte GetByteRef(int row, int columnID)
 01127        {
 01128            return ref GetCellRef(row, columnID, ref allByteColumns);
 01129        }
 1130
 1131        public ref short GetShortRef(int row, int column)
 01132        {
 01133            return ref GetCellRef(row, column, ref allShortColumns);
 01134        }
 1135
 1136        public ref ushort GetUshortRef(int row, int column)
 01137        {
 01138            return ref GetCellRef(row, column, ref allUshortColumns);
 01139        }
 1140
 1141        public ref int GetIntRef(int row, int column)
 01142        {
 01143            return ref GetCellRef(row, column, ref allIntColumns);
 01144        }
 1145
 1146        public ref uint GetUintRef(int row, int column)
 01147        {
 01148            return ref GetCellRef(row, column, ref allUintColumns);
 01149        }
 1150
 1151        public ref long GetLongRef(int row, int column)
 01152        {
 01153            return ref GetCellRef(row, column, ref allLongColumns);
 01154        }
 1155
 1156        public ref ulong GetUlongRef(int row, int column)
 01157        {
 01158            return ref GetCellRef(row, column, ref allUlongColumns);
 01159        }
 1160
 1161        public ref float GetFloatRef(int row, int column)
 01162        {
 01163            return ref GetCellRef(row, column, ref allFloatColumns);
 01164        }
 1165
 1166        public ref double GetDoubleRef(int row, int column)
 01167        {
 01168            return ref GetCellRef(row, column, ref allDoubleColumns);
 01169        }
 1170
 1171        public ref Vector2 GetVector2Ref(int row, int column)
 01172        {
 01173            return ref GetCellRef(row, column, ref allVector2Columns);
 01174        }
 1175
 1176        public ref Vector3 GetVector3Ref(int row, int column)
 01177        {
 01178            return ref GetCellRef(row, column, ref allVector3Columns);
 01179        }
 1180
 1181        public ref Vector4 GetVector4Ref(int row, int column)
 01182        {
 01183            return ref GetCellRef(row, column, ref allVector4Columns);
 01184        }
 1185
 1186        public ref Vector2Int GetVector2IntRef(int row, int column)
 01187        {
 01188            return ref GetCellRef(row, column, ref allVector2IntColumns);
 01189        }
 1190
 1191        public ref Vector3Int GetVector3IntRef(int row, int column)
 01192        {
 01193            return ref GetCellRef(row, column, ref allVector3IntColumns);
 01194        }
 1195
 1196        public ref Quaternion GetQuaternionRef(int row, int column)
 01197        {
 01198            return ref GetCellRef(row, column, ref allQuaternionColumns);
 01199        }
 1200
 1201        public ref Rect GetRectRef(int row, int column)
 01202        {
 01203            return ref GetCellRef(row, column, ref allRectColumns);
 01204        }
 1205
 1206        public ref RectInt GetRectIntRef(int row, int column)
 01207        {
 01208            return ref GetCellRef(row, column, ref allRectIntColumns);
 01209        }
 1210
 1211        public ref Color GetColorRef(int row, int column)
 01212        {
 01213            return ref GetCellRef(row, column, ref allColorColumns);
 01214        }
 1215
 1216        public ref LayerMask GetLayerMaskRef(int row, int column)
 01217        {
 01218            return ref GetCellRef(row, column, ref allLayerMaskColumns);
 01219        }
 1220
 1221        public ref Bounds GetBoundsRef(int row, int column)
 01222        {
 01223            return ref GetCellRef(row, column, ref allBoundsColumns);
 01224        }
 1225
 1226        public ref BoundsInt GetBoundsIntRef(int row, int column)
 01227        {
 01228            return ref GetCellRef(row, column, ref allBoundsIntColumns);
 01229        }
 1230
 1231        public ref Hash128 GetHash128Ref(int row, int column)
 01232        {
 01233            return ref GetCellRef(row, column, ref allHash128Columns);
 01234        }
 1235
 1236        public ref Gradient GetGradientRef(int row, int column)
 01237        {
 01238            return ref GetCellRef(row, column, ref allGradientColumns);
 01239        }
 1240
 1241        public ref AnimationCurve GetAnimationCurveRef(int row, int column)
 01242        {
 01243            return ref GetCellRef(row, column, ref allAnimationCurveColumns);
 01244        }
 1245
 1246        public ref UnityEngine.Object GetObjectRef(int row, int column)
 01247        {
 01248            return ref GetCellRef(row, column, ref allObjectRefColumns);
 01249        }
 1250
 1251        // Get Column
 1252
 1253        public string[] GetStringColumn(int column)
 01254        {
 01255            return GetColumn(column, ref allStringColumns);
 01256        }
 1257
 1258        public bool[] GetBoolColumn(int column)
 01259        {
 01260            return GetColumn(column, ref allBoolColumns);
 01261        }
 1262
 1263        public char[] GetCharColumn(int column)
 01264        {
 01265            return GetColumn(column, ref allCharColumns);
 01266        }
 1267
 1268        public sbyte[] GetSbyteColumn(int column)
 01269        {
 01270            return GetColumn(column, ref allSbyteColumns);
 01271        }
 1272
 1273        public byte[] GetByteColumn(int column)
 01274        {
 01275            return GetColumn(column, ref allByteColumns);
 01276        }
 1277
 1278        public short[] GetShortColumn(int column)
 01279        {
 01280            return GetColumn(column, ref allShortColumns);
 01281        }
 1282
 1283        public ushort[] GetUshortColumn(int column)
 01284        {
 01285            return GetColumn(column, ref allUshortColumns);
 01286        }
 1287
 1288        public int[] GetIntColumn(int column)
 01289        {
 01290            return GetColumn(column, ref allIntColumns);
 01291        }
 1292
 1293        public uint[] GetUintColumn(int column)
 01294        {
 01295            return GetColumn(column, ref allUintColumns);
 01296        }
 1297
 1298        public long[] GetLongColumn(int column)
 01299        {
 01300            return GetColumn(column, ref allLongColumns);
 01301        }
 1302
 1303        public ulong[] GetUlongColumn(int column)
 01304        {
 01305            return GetColumn(column, ref allUlongColumns);
 01306        }
 1307
 1308        public float[] GetFloatColumn(int column)
 01309        {
 01310            return GetColumn(column, ref allFloatColumns);
 01311        }
 1312
 1313        public double[] GetDoubleColumn(int column)
 01314        {
 01315            return GetColumn(column, ref allDoubleColumns);
 01316        }
 1317
 1318        public Vector2[] GetVector2Column(int column)
 01319        {
 01320            return GetColumn(column, ref allVector2Columns);
 01321        }
 1322
 1323        public Vector3[] GetVector3Column(int column)
 01324        {
 01325            return GetColumn(column, ref allVector3Columns);
 01326        }
 1327
 1328        public Vector4[] GetVector4Column(int column)
 01329        {
 01330            return GetColumn(column, ref allVector4Columns);
 01331        }
 1332
 1333        public Vector2Int[] GetVector2IntColumn(int column)
 01334        {
 01335            return GetColumn(column, ref allVector2IntColumns);
 01336        }
 1337
 1338        public Vector3Int[] GetVector3IntColumn(int column)
 01339        {
 01340            return GetColumn(column, ref allVector3IntColumns);
 01341        }
 1342
 1343        public Quaternion[] GetQuaternionColumn(int column)
 01344        {
 01345            return GetColumn(column, ref allQuaternionColumns);
 01346        }
 1347
 1348        public Rect[] GetRectColumn(int column)
 01349        {
 01350            return GetColumn(column, ref allRectColumns);
 01351        }
 1352
 1353        public RectInt[] GetRectIntColumn(int column)
 01354        {
 01355            return GetColumn(column, ref allRectIntColumns);
 01356        }
 1357
 1358        public Color[] GetColorColumn(int column)
 01359        {
 01360            return GetColumn(column, ref allColorColumns);
 01361        }
 1362
 1363        public LayerMask[] GetLayerMaskColumn(int column)
 01364        {
 01365            return GetColumn(column, ref allLayerMaskColumns);
 01366        }
 1367
 1368        public Bounds[] GetBoundsColumn(int column)
 01369        {
 01370            return GetColumn(column, ref allBoundsColumns);
 01371        }
 1372
 1373        public BoundsInt[] GetBoundsIntColumn(int column)
 01374        {
 01375            return GetColumn(column, ref allBoundsIntColumns);
 01376        }
 1377
 1378        public Hash128[] GetHash128Column(int column)
 01379        {
 01380            return GetColumn(column, ref allHash128Columns);
 01381        }
 1382
 1383        public Gradient[] GetGradientColumn(int column)
 01384        {
 01385            return GetColumn(column, ref allGradientColumns);
 01386        }
 1387
 1388        public AnimationCurve[] GetAnimationCurveColumn(int column)
 01389        {
 01390            return GetColumn(column, ref allAnimationCurveColumns);
 01391        }
 1392
 1393        public UnityEngine.Object[] GetObjectColumn(int column)
 01394        {
 01395            return GetColumn(column, ref allObjectRefColumns);
 01396        }
 1397
 1398        // SetOrder
 1399
 1400        public void SetColumnOrder(int columnID, int newSortOrder)
 01401        {
 01402            AssertColumnIDValid(columnID);
 01403            AssertColumnSortOrderValid(newSortOrder);
 01404            int oldSortOrder = columnIDToSortOrderMap[columnID];
 01405            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01406            for (int i = oldSortOrder; i != newSortOrder; i += iterDirection)
 01407            {
 01408                int columnIDAt = sortedOrderToColumnIDMap[i + iterDirection];
 01409                columnIDToSortOrderMap[columnIDAt] = i;
 01410                sortedOrderToColumnIDMap[i] = sortedOrderToColumnIDMap[i + iterDirection];
 01411            }
 1412
 01413            sortedOrderToColumnIDMap[newSortOrder] = columnID;
 01414            columnIDToSortOrderMap[columnID] = newSortOrder;
 01415        }
 1416
 1417        public void SetAllColumnOrders(int[] sortedColumnIDs)
 01418        {
 01419            AssertSortedColumnsArgValid(sortedColumnIDs);
 01420            for (int i = 0; i < sortedOrderToColumnIDMap.Length; i++)
 01421            {
 01422                int columnID = sortedColumnIDs[i];
 01423                sortedOrderToColumnIDMap[i] = columnID;
 01424                columnIDToSortOrderMap[columnID] = i;
 01425            }
 01426        }
 1427
 1428        public void SetRowOrder(int rowID, int newSortOrder)
 01429        {
 01430            AssertRowIDValid(rowID);
 01431            AssertRowSortOrderValid(newSortOrder);
 1432
 01433            int oldSortOrder = rowIDToDenseIndexMap[rowID];
 01434            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 1435
 01436            for (int i = oldSortOrder; i != newSortOrder; i += iterDirection)
 01437            {
 01438                int rowIDAt = rowDenseIndexToIDMap[i + iterDirection];
 01439                rowIDToDenseIndexMap[rowIDAt] = i;
 01440                rowDenseIndexToIDMap[i] = rowDenseIndexToIDMap[i + iterDirection];
 01441            }
 1442
 01443            SetRowOrderForColumns(allStringColumns, oldSortOrder, newSortOrder);
 01444            SetRowOrderForColumns(allBoolColumns, oldSortOrder, newSortOrder);
 01445            SetRowOrderForColumns(allCharColumns, oldSortOrder, newSortOrder);
 01446            SetRowOrderForColumns(allSbyteColumns, oldSortOrder, newSortOrder);
 01447            SetRowOrderForColumns(allByteColumns, oldSortOrder, newSortOrder);
 01448            SetRowOrderForColumns(allShortColumns, oldSortOrder, newSortOrder);
 01449            SetRowOrderForColumns(allUshortColumns, oldSortOrder, newSortOrder);
 01450            SetRowOrderForColumns(allIntColumns, oldSortOrder, newSortOrder);
 01451            SetRowOrderForColumns(allUintColumns, oldSortOrder, newSortOrder);
 01452            SetRowOrderForColumns(allLongColumns, oldSortOrder, newSortOrder);
 01453            SetRowOrderForColumns(allUlongColumns, oldSortOrder, newSortOrder);
 01454            SetRowOrderForColumns(allFloatColumns, oldSortOrder, newSortOrder);
 01455            SetRowOrderForColumns(allDoubleColumns, oldSortOrder, newSortOrder);
 01456            SetRowOrderForColumns(allVector2Columns, oldSortOrder, newSortOrder);
 01457            SetRowOrderForColumns(allVector3Columns, oldSortOrder, newSortOrder);
 01458            SetRowOrderForColumns(allVector4Columns, oldSortOrder, newSortOrder);
 01459            SetRowOrderForColumns(allVector2IntColumns, oldSortOrder, newSortOrder);
 01460            SetRowOrderForColumns(allVector3IntColumns, oldSortOrder, newSortOrder);
 01461            SetRowOrderForColumns(allQuaternionColumns, oldSortOrder, newSortOrder);
 01462            SetRowOrderForColumns(allRectColumns, oldSortOrder, newSortOrder);
 01463            SetRowOrderForColumns(allRectIntColumns, oldSortOrder, newSortOrder);
 01464            SetRowOrderForColumns(allColorColumns, oldSortOrder, newSortOrder);
 01465            SetRowOrderForColumns(allLayerMaskColumns, oldSortOrder, newSortOrder);
 01466            SetRowOrderForColumns(allBoundsColumns, oldSortOrder, newSortOrder);
 01467            SetRowOrderForColumns(allBoundsIntColumns, oldSortOrder, newSortOrder);
 01468            SetRowOrderForColumns(allHash128Columns, oldSortOrder, newSortOrder);
 01469            SetRowOrderForColumns(allGradientColumns, oldSortOrder, newSortOrder);
 01470            SetRowOrderForColumns(allAnimationCurveColumns, oldSortOrder, newSortOrder);
 01471            SetRowOrderForColumns(allObjectRefColumns, oldSortOrder, newSortOrder);
 01472        }
 1473
 1474        public void SetAllRowOrders(int[] sortedRowIDs)
 01475        {
 01476            AssertSorteRowsArgValid(sortedRowIDs);
 1477
 01478            ReSortRows(allStringColumns, sortedRowIDs);
 01479            ReSortRows(allBoolColumns, sortedRowIDs);
 01480            ReSortRows(allCharColumns, sortedRowIDs);
 01481            ReSortRows(allSbyteColumns, sortedRowIDs);
 01482            ReSortRows(allByteColumns, sortedRowIDs);
 01483            ReSortRows(allShortColumns, sortedRowIDs);
 01484            ReSortRows(allUshortColumns, sortedRowIDs);
 01485            ReSortRows(allIntColumns, sortedRowIDs);
 01486            ReSortRows(allUintColumns, sortedRowIDs);
 01487            ReSortRows(allLongColumns, sortedRowIDs);
 01488            ReSortRows(allUlongColumns, sortedRowIDs);
 01489            ReSortRows(allFloatColumns, sortedRowIDs);
 01490            ReSortRows(allDoubleColumns, sortedRowIDs);
 01491            ReSortRows(allVector2Columns, sortedRowIDs);
 01492            ReSortRows(allVector3Columns, sortedRowIDs);
 01493            ReSortRows(allVector4Columns, sortedRowIDs);
 01494            ReSortRows(allVector2IntColumns, sortedRowIDs);
 01495            ReSortRows(allVector3IntColumns, sortedRowIDs);
 01496            ReSortRows(allQuaternionColumns, sortedRowIDs);
 01497            ReSortRows(allRectColumns, sortedRowIDs);
 01498            ReSortRows(allRectIntColumns, sortedRowIDs);
 01499            ReSortRows(allColorColumns, sortedRowIDs);
 01500            ReSortRows(allLayerMaskColumns, sortedRowIDs);
 01501            ReSortRows(allBoundsColumns, sortedRowIDs);
 01502            ReSortRows(allBoundsIntColumns, sortedRowIDs);
 01503            ReSortRows(allHash128Columns, sortedRowIDs);
 01504            ReSortRows(allGradientColumns, sortedRowIDs);
 01505            ReSortRows(allAnimationCurveColumns, sortedRowIDs);
 01506            ReSortRows(allObjectRefColumns, sortedRowIDs);
 1507
 01508            for (int i = 0; i < sortedRowIDs.Length; i++)
 01509            {
 01510                int rowID = sortedRowIDs[i];
 01511                rowDenseIndexToIDMap[i] = rowID;
 01512                rowIDToDenseIndexMap[rowID] = i;
 01513            }
 01514        }
 1515
 1516        internal void ReSortRows<T>(ArrayHolder<T>[] columns, int[] sortedRowIDs)
 01517        {
 01518            int columnCount = columns?.Length ?? 0;
 01519            for (int i = 0; i < columnCount; i++)
 01520            {
 01521                T[] column = columns[i].TArray;
 01522                T[] newColumn = new T[column.Length];
 01523                for (int j = 0; j < sortedRowIDs.Length; j++)
 01524                {
 01525                    int rowID = sortedRowIDs[j];
 01526                    int oldRowIndex = rowIDToDenseIndexMap[rowID];
 1527
 01528                    newColumn[j] = column[oldRowIndex];
 01529                }
 1530
 01531                columns[i].TArray = newColumn;
 01532            }
 01533        }
 1534
 1535        // Internal
 1536
 1537        internal int AddColumnInternal<T>(string columnName, ref ArrayHolder<T>[] allColumnsOfType, Serializable.Seriali
 01538        {
 01539            if (insertAtColumnID >= 0)
 01540            {
 01541                AssertColumnIDValid(insertAtColumnID);
 01542            }
 01543            int columnCount = allColumnsOfType?.Length ?? 0;
 01544            Array.Resize(ref allColumnsOfType, columnCount + 1);
 01545            allColumnsOfType[columnCount].TArray = new T[rowCount];
 1546
 01547            int columnID = columnEntriesFreeListHead;
 01548            string[] columnNamesForType = allColumnNames[(int)typeIndex].TArray;
 01549            int columnNamesCount = columnNamesForType?.Length ?? 0;
 01550            Array.Resize(ref columnNamesForType, columnNamesCount + 1);
 01551            columnNamesForType[columnNamesCount] = columnName == null ? columnID.ToString() : columnName;
 01552            allColumnNames[(int)typeIndex].TArray = columnNamesForType;
 1553
 1554
 01555            int columnIDToDenseIndexMapLength = columnIDToDenseIndexMap?.Length ?? 0;
 01556            if (columnID >= columnIDToDenseIndexMapLength)
 01557            {
 01558                int newSize = columnIDToDenseIndexMapLength * 2;
 01559                newSize = newSize == 0 ? 1 : newSize;
 01560                Array.Resize(ref columnIDToDenseIndexMap, newSize);
 01561                for (int i = columnIDToDenseIndexMapLength; i < newSize; i++)
 01562                {
 01563                    ref ColumnEntry entry = ref columnIDToDenseIndexMap[i];
 01564                    entry.columnDenseIndex = i + 1;
 01565                    entry.ColumnType = Serializable.SerializableTypes.Invalid;
 01566                }
 1567
 01568                Array.Resize(ref columnIDToSortOrderMap, newSize);
 01569                for (int i = columnIDToDenseIndexMapLength; i < newSize; i++)
 01570                {
 01571                    columnIDToSortOrderMap[i] = -1;
 01572                }
 01573            }
 1574
 01575            columnEntriesFreeListHead = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 1576
 01577            ref int[] denseIndexToIDMap = ref columnDenseIndexToIDMap[(int)typeIndex].TArray;
 01578            int denseIndexToIDMapLength = denseIndexToIDMap?.Length ?? 0;
 01579            Array.Resize(ref denseIndexToIDMap, denseIndexToIDMapLength + 1);
 01580            denseIndexToIDMap[denseIndexToIDMapLength] = columnID;
 1581
 01582            ref ColumnEntry newEntry = ref columnIDToDenseIndexMap[columnID];
 01583            newEntry.columnDenseIndex = denseIndexToIDMapLength;
 01584            newEntry.ColumnType = typeIndex;
 1585
 01586            int insertAtSortedIndex = insertAtColumnID < 0 ? combinedColumnCount : columnIDToSortOrderMap[insertAtColumn
 01587            Array.Resize(ref sortedOrderToColumnIDMap, combinedColumnCount + 1);
 01588            for (int i = combinedColumnCount; i > insertAtSortedIndex; i--)
 01589            {
 01590                int currentColumnID = sortedOrderToColumnIDMap[i - 1];
 01591                sortedOrderToColumnIDMap[i] = currentColumnID;
 01592                columnIDToSortOrderMap[currentColumnID] = i;
 01593            }
 1594
 1595
 01596            columnIDToSortOrderMap[columnID] = insertAtSortedIndex;
 01597            sortedOrderToColumnIDMap[insertAtSortedIndex] = columnID;
 1598
 01599            ++combinedColumnCount;
 01600            dataVersion++;
 1601
 01602            return columnID;
 01603        }
 1604
 1605        internal void RemoveColumnInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, Serializable.SerializableTypes type
 01606        {
 01607            AssertColumnIDValid(columnID);
 01608            int columnLocation = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 1609
 01610            int lastIndex = allColumnsOfType.Length - 1;
 01611            allColumnsOfType[columnLocation] = allColumnsOfType[lastIndex];
 01612            Array.Resize(ref allColumnsOfType, lastIndex);
 1613
 01614            ref string[] columnNamesOfType = ref allColumnNames[(int)typeIndex].TArray;
 01615            columnNamesOfType[columnLocation] = columnNamesOfType[lastIndex];
 01616            Array.Resize(ref columnNamesOfType, lastIndex);
 1617
 01618            int columnOrder = columnIDToSortOrderMap[columnID];
 1619
 01620            ref int[] denseIndicesOfType = ref columnDenseIndexToIDMap[(int)typeIndex].TArray;
 01621            int sparseIndexToSwap = denseIndicesOfType[lastIndex];
 1622
 01623            ref ColumnEntry sparseIndexToFree = ref columnIDToDenseIndexMap[columnID];
 01624            sparseIndexToFree.ColumnType = Serializable.SerializableTypes.Invalid;
 01625            sparseIndexToFree.columnDenseIndex = columnEntriesFreeListHead;
 01626            columnEntriesFreeListHead = columnID;
 1627
 01628            columnIDToDenseIndexMap[sparseIndexToSwap].columnDenseIndex = columnLocation;
 01629            denseIndicesOfType[columnLocation] = sparseIndexToSwap;
 01630            Array.Resize(ref denseIndicesOfType, lastIndex);
 1631
 01632            for (int i = columnOrder + 1; i < combinedColumnCount; i++)
 01633            {
 01634                int currentColumnID = sortedOrderToColumnIDMap[i];
 01635                sortedOrderToColumnIDMap[i - 1] = currentColumnID;
 01636                columnIDToSortOrderMap[currentColumnID] = i - 1;
 01637            }
 1638
 01639            Array.Resize(ref sortedOrderToColumnIDMap, combinedColumnCount - 1);
 1640
 01641            --combinedColumnCount;
 01642            dataVersion++;
 01643        }
 1644
 1645        internal void InsertRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int insertAt, int numberOfNewRo
 01646        {
 01647            int columnCount = allColumnsOfType?.Length ?? 0;
 01648            for (int i = 0; i < columnCount; i++)
 01649            {
 01650                ref T[] rows = ref allColumnsOfType[i].TArray;
 01651                int newRowCount = rowCount + numberOfNewRows;
 01652                Array.Resize(ref rows, newRowCount);
 01653                for (int j = newRowCount - 1; j > insertAt + numberOfNewRows - 1; j--)
 01654                {
 01655                    rows[j] = rows[j - numberOfNewRows];
 01656                }
 1657
 01658                for (int j = 0; j < numberOfNewRows; j++)
 01659                {
 01660                    rows[insertAt + j] = default;
 01661                }
 01662            }
 01663        }
 1664
 1665        internal void DeleteRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int removeAt, int numberOfRowsT
 01666        {
 01667            int columnCount = allColumnsOfType?.Length ?? 0;
 1668
 01669            for (int i = 0; i < columnCount; i++)
 01670            {
 01671                ref T[] rows = ref allColumnsOfType[i].TArray;
 01672                int newRowCount = rowCount - numberOfRowsToDelete;
 1673
 01674                for (int j = removeAt + numberOfRowsToDelete; j < rowCount; j++)
 01675                {
 01676                    rows[j - numberOfRowsToDelete] = rows[j];
 01677                }
 1678
 01679                Array.Resize(ref rows, newRowCount);
 01680            }
 01681        }
 1682
 1683        internal ref T GetCellRef<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01684        {
 01685            AssertColumnIDValid(columnID);
 01686            AssertRowIDValid(rowID);
 01687            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01688            int row = rowIDToDenseIndexMap[rowID];
 01689            return ref allColumnsOfType[column][row];
 01690        }
 1691
 1692        internal T GetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01693        {
 01694            AssertColumnIDValid(columnID);
 01695            AssertRowIDValid(rowID);
 01696            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01697            int row = rowIDToDenseIndexMap[rowID];
 01698            return allColumnsOfType[column][row];
 01699        }
 1700
 1701        internal ulong SetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType, T value)
 01702        {
 01703            AssertColumnIDValid(columnID);
 01704            AssertRowIDValid(rowID);
 01705            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01706            int row = rowIDToDenseIndexMap[rowID];
 01707            allColumnsOfType[column][row] = value;
 01708            dataVersion++;
 01709            return dataVersion;
 01710        }
 1711
 1712        internal T[] GetColumn<T>(int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01713        {
 01714            AssertColumnIDValid(columnID);
 01715            int column = columnIDToDenseIndexMap[columnID].columnDenseIndex;
 01716            return allColumnsOfType[column].TArray;
 01717        }
 1718
 1719        internal void SetRowOrderForColumns<T>(ArrayHolder<T>[] columns, int oldSortOrder, int newSortOrder)
 01720        {
 01721            int columnCount = columns?.Length ?? 0;
 01722            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01723            for (int i = 0; i < columnCount; i++)
 01724            {
 01725                T[] column = columns[i].TArray;
 1726
 01727                for (int j = oldSortOrder; j != newSortOrder; j += iterDirection)
 01728                {
 01729                    column[j] = column[j + iterDirection];
 01730                }
 01731            }
 01732        }
 1733
 1734        internal void AssertSortedColumnsArgValid(int[] sortedColumnIDs)
 01735        {
 01736            if (sortedColumnIDs == null)
 01737            {
 01738                throw new ArgumentException("sortedColumnIDs array cannot be null.");
 1739            }
 1740
 01741            if (sortedColumnIDs.Length != sortedOrderToColumnIDMap.Length)
 01742            {
 01743                throw new ArgumentException("sortedColumnIDs array must be the same length as GetColumnCount.");
 1744            }
 1745
 01746            for (int i = 0; i < sortedColumnIDs.Length; i++)
 01747            {
 01748                AssertColumnIDValid(sortedColumnIDs[i]);
 01749            }
 01750        }
 1751
 1752        internal void AssertColumnSortOrderValid(int sortedOrder)
 01753        {
 01754            if (sortedOrder >= combinedColumnCount || sortedOrder < 0)
 01755            {
 01756                throw new ArgumentException("Invalid column sort order argument: " + sortedOrder);
 1757            }
 01758        }
 1759
 1760        internal void AssertRowSortOrderValid(int sortedOrder)
 01761        {
 01762            if (sortedOrder >= rowCount || sortedOrder < 0)
 01763            {
 01764                throw new ArgumentException("Invalid row sort order argument: " + sortedOrder);
 1765            }
 01766        }
 1767
 1768        internal void AssertSorteRowsArgValid(int[] sortedRowIDs)
 01769        {
 01770            if (sortedRowIDs == null)
 01771            {
 01772                throw new ArgumentException("sortedRowIDs array cannot be null.");
 1773            }
 1774
 01775            if (sortedRowIDs.Length != rowDenseIndexToIDMap.Length)
 01776            {
 01777                throw new ArgumentException("sortedRowIDs array must be the same length as GetRowCount.");
 1778            }
 1779
 01780            for (int i = 0; i < sortedRowIDs.Length; i++)
 01781            {
 01782                AssertRowIDValid(sortedRowIDs[i]);
 01783            }
 01784        }
 1785    }
 1786}
Generated by: ReportGenerator 5.0.4.0
2023-05-26 - 1:03:45 AM
GitHub | www.palmmedia.de

Coverage by test methods





































































































































































































































































































































































































































































































































































































































































































Methods/Properties

StableTable()
GetDataVersion()
GetColumnCount()
GetRowCount()
GetDisplayName()
SetDisplayName(System.String)
GetFlag(GDX.Tables.ITable/Flags)
SetFlag(GDX.Tables.ITable/Flags, System.Boolean)
GetAllRowDescriptions()
GetRowDescription(System.String)
GetRowDescription(System.Int32)
SetAllRowDescriptionsOrder(GDX.Tables.ITable/RowDescription[])
GetColumnDescription(System.String)
GetColumnDescription(System.Int32)
SetAllColumnDescriptionsOrder(GDX.Tables.ITable/ColumnDescription[])
GetAllColumnDescriptions()
AssertColumnIDValid(System.Int32)
AssertRowIDValid(System.Int32)
SetColumnName(System.String, System.Int32)
GetColumnName(System.Int32)
SetRowName(System.String, System.Int32)
GetRowName(System.Int32)
GetRowNameRef(System.Int32)
GetColumnNameRef(System.Int32)
AddRow(System.String, System.Int32)
AddRows(System.Int32, System.String[], System.Int32)
AddRows(System.Int32, System.Int32[]&, System.String[], System.Int32)
RemoveRow(System.Int32)
AddColumn(GDX.Serializable/SerializableTypes, System.String, System.Int32)
RemoveColumn(GDX.Serializable/SerializableTypes, System.Int32)
SetString(System.Int32, System.Int32, System.String)
SetBool(System.Int32, System.Int32, System.Boolean)
SetChar(System.Int32, System.Int32, System.Char)
SetSByte(System.Int32, System.Int32, System.SByte)
SetByte(System.Int32, System.Int32, System.Byte)
SetShort(System.Int32, System.Int32, System.Int16)
SetUShort(System.Int32, System.Int32, System.UInt16)
SetInt(System.Int32, System.Int32, System.Int32)
SetUInt(System.Int32, System.Int32, System.UInt32)
SetLong(System.Int32, System.Int32, System.Int64)
SetULong(System.Int32, System.Int32, System.UInt64)
SetFloat(System.Int32, System.Int32, System.Single)
SetDouble(System.Int32, System.Int32, System.Double)
SetVector2(System.Int32, System.Int32, UnityEngine.Vector2)
SetVector3(System.Int32, System.Int32, UnityEngine.Vector3)
SetVector4(System.Int32, System.Int32, UnityEngine.Vector4)
SetVector2Int(System.Int32, System.Int32, UnityEngine.Vector2Int)
SetVector3Int(System.Int32, System.Int32, UnityEngine.Vector3Int)
SetQuaternion(System.Int32, System.Int32, UnityEngine.Quaternion)
SetRect(System.Int32, System.Int32, UnityEngine.Rect)
SetRectInt(System.Int32, System.Int32, UnityEngine.RectInt)
SetColor(System.Int32, System.Int32, UnityEngine.Color)
SetLayerMask(System.Int32, System.Int32, UnityEngine.LayerMask)
SetBounds(System.Int32, System.Int32, UnityEngine.Bounds)
SetBoundsInt(System.Int32, System.Int32, UnityEngine.BoundsInt)
SetHash128(System.Int32, System.Int32, UnityEngine.Hash128)
SetGradient(System.Int32, System.Int32, UnityEngine.Gradient)
SetAnimationCurve(System.Int32, System.Int32, UnityEngine.AnimationCurve)
SetObject(System.Int32, System.Int32, UnityEngine.Object)
GetString(System.Int32, System.Int32)
GetBool(System.Int32, System.Int32)
GetChar(System.Int32, System.Int32)
GetSByte(System.Int32, System.Int32)
GetByte(System.Int32, System.Int32)
GetShort(System.Int32, System.Int32)
GetUShort(System.Int32, System.Int32)
GetInt(System.Int32, System.Int32)
GetUInt(System.Int32, System.Int32)
GetLong(System.Int32, System.Int32)
GetULong(System.Int32, System.Int32)
GetFloat(System.Int32, System.Int32)
GetDouble(System.Int32, System.Int32)
GetVector2(System.Int32, System.Int32)
GetVector3(System.Int32, System.Int32)
GetVector4(System.Int32, System.Int32)
GetVector2Int(System.Int32, System.Int32)
GetVector3Int(System.Int32, System.Int32)
GetQuaternion(System.Int32, System.Int32)
GetRect(System.Int32, System.Int32)
GetRectInt(System.Int32, System.Int32)
GetColor(System.Int32, System.Int32)
GetLayerMask(System.Int32, System.Int32)
GetBounds(System.Int32, System.Int32)
GetBoundsInt(System.Int32, System.Int32)
GetHash128(System.Int32, System.Int32)
GetGradient(System.Int32, System.Int32)
GetAnimationCurve(System.Int32, System.Int32)
GetObject(System.Int32, System.Int32)
GetStringRef(System.Int32, System.Int32)
GetBoolRef(System.Int32, System.Int32)
GetCharRef(System.Int32, System.Int32)
GetSbyteRef(System.Int32, System.Int32)
GetByteRef(System.Int32, System.Int32)
GetShortRef(System.Int32, System.Int32)
GetUshortRef(System.Int32, System.Int32)
GetIntRef(System.Int32, System.Int32)
GetUintRef(System.Int32, System.Int32)
GetLongRef(System.Int32, System.Int32)
GetUlongRef(System.Int32, System.Int32)
GetFloatRef(System.Int32, System.Int32)
GetDoubleRef(System.Int32, System.Int32)
GetVector2Ref(System.Int32, System.Int32)
GetVector3Ref(System.Int32, System.Int32)
GetVector4Ref(System.Int32, System.Int32)
GetVector2IntRef(System.Int32, System.Int32)
GetVector3IntRef(System.Int32, System.Int32)
GetQuaternionRef(System.Int32, System.Int32)
GetRectRef(System.Int32, System.Int32)
GetRectIntRef(System.Int32, System.Int32)
GetColorRef(System.Int32, System.Int32)
GetLayerMaskRef(System.Int32, System.Int32)
GetBoundsRef(System.Int32, System.Int32)
GetBoundsIntRef(System.Int32, System.Int32)
GetHash128Ref(System.Int32, System.Int32)
GetGradientRef(System.Int32, System.Int32)
GetAnimationCurveRef(System.Int32, System.Int32)
GetObjectRef(System.Int32, System.Int32)
GetStringColumn(System.Int32)
GetBoolColumn(System.Int32)
GetCharColumn(System.Int32)
GetSbyteColumn(System.Int32)
GetByteColumn(System.Int32)
GetShortColumn(System.Int32)
GetUshortColumn(System.Int32)
GetIntColumn(System.Int32)
GetUintColumn(System.Int32)
GetLongColumn(System.Int32)
GetUlongColumn(System.Int32)
GetFloatColumn(System.Int32)
GetDoubleColumn(System.Int32)
GetVector2Column(System.Int32)
GetVector3Column(System.Int32)
GetVector4Column(System.Int32)
GetVector2IntColumn(System.Int32)
GetVector3IntColumn(System.Int32)
GetQuaternionColumn(System.Int32)
GetRectColumn(System.Int32)
GetRectIntColumn(System.Int32)
GetColorColumn(System.Int32)
GetLayerMaskColumn(System.Int32)
GetBoundsColumn(System.Int32)
GetBoundsIntColumn(System.Int32)
GetHash128Column(System.Int32)
GetGradientColumn(System.Int32)
GetAnimationCurveColumn(System.Int32)
GetObjectColumn(System.Int32)
SetColumnOrder(System.Int32, System.Int32)
SetAllColumnOrders(System.Int32[])
SetRowOrder(System.Int32, System.Int32)
SetAllRowOrders(System.Int32[])
ReSortRows[T](, System.Int32[])
AddColumnInternal[T](System.String, , GDX.Serializable/SerializableTypes, System.Int32)
RemoveColumnInternal[T](, GDX.Serializable/SerializableTypes, System.Int32)
InsertRowsOfTypeInternal[T](, System.Int32, System.Int32)
DeleteRowsOfTypeInternal[T](, System.Int32, System.Int32)
GetCellRef[T](System.Int32, System.Int32, )
GetCell[T](System.Int32, System.Int32, )
SetCell[T](System.Int32, System.Int32, , T)
GetColumn[T](System.Int32, )
SetRowOrderForColumns[T](, System.Int32, System.Int32)
AssertSortedColumnsArgValid(System.Int32[])
AssertColumnSortOrderValid(System.Int32)
AssertRowSortOrderValid(System.Int32)
AssertSorteRowsArgValid(System.Int32[])